# Generated from anltr/RuleParser.g4 by ANTLR 4.9.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3O")
        buf.write("\u0119\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\3\2\6")
        buf.write("\2L\n\2\r\2\16\2M\3\3\3\3\5\3R\n\3\3\3\3\3\3\3\7\3W\n")
        buf.write("\3\f\3\16\3Z\13\3\3\3\3\3\3\4\3\4\3\4\5\4a\n\4\3\4\5\4")
        buf.write("d\n\4\3\4\5\4g\n\4\5\4i\n\4\3\4\3\4\3\4\3\5\3\5\3\5\3")
        buf.write("\5\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\b\3\b\6\b|\n\b\r")
        buf.write("\b\16\b}\3\b\3\b\3\b\3\t\3\t\5\t\u0085\n\t\3\n\3\n\3\n")
        buf.write("\5\n\u008a\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u009e\n\n\3\13\3")
        buf.write("\13\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16")
        buf.write("\3\16\3\17\3\17\3\17\3\20\3\20\3\20\3\21\3\21\3\21\3\22")
        buf.write("\3\22\3\22\3\23\3\23\3\23\3\24\3\24\3\24\3\25\3\25\3\26")
        buf.write("\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\31")
        buf.write("\3\31\3\31\3\32\3\32\3\32\3\33\3\33\3\33\3\34\3\34\3\34")
        buf.write("\3\34\3\34\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36")
        buf.write("\3\36\5\36\u00e6\n\36\3\36\3\36\3\36\3\36\7\36\u00ec\n")
        buf.write("\36\f\36\16\36\u00ef\13\36\3\37\3\37\3\37\3\37\3\37\5")
        buf.write("\37\u00f6\n\37\3 \3 \3!\3!\3!\3!\3\"\3\"\3#\3#\3#\3$\3")
        buf.write("$\3%\3%\3%\3%\3%\3%\3%\3%\3%\5%\u010e\n%\3%\3%\3%\3%\7")
        buf.write("%\u0114\n%\f%\16%\u0117\13%\3%\2\4:H&\2\4\6\b\n\f\16\20")
        buf.write("\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFH\2")
        buf.write("\b\3\2&)\4\2&\'++\3\2DG\4\2\5\6HH\3\2=B\3\2;<\2\u0119")
        buf.write("\2K\3\2\2\2\4O\3\2\2\2\6]\3\2\2\2\bm\3\2\2\2\nq\3\2\2")
        buf.write("\2\fu\3\2\2\2\16y\3\2\2\2\20\u0084\3\2\2\2\22\u0089\3")
        buf.write("\2\2\2\24\u009f\3\2\2\2\26\u00a1\3\2\2\2\30\u00a5\3\2")
        buf.write("\2\2\32\u00ab\3\2\2\2\34\u00ae\3\2\2\2\36\u00b1\3\2\2")
        buf.write("\2 \u00b4\3\2\2\2\"\u00b7\3\2\2\2$\u00ba\3\2\2\2&\u00bd")
        buf.write("\3\2\2\2(\u00c0\3\2\2\2*\u00c2\3\2\2\2,\u00c5\3\2\2\2")
        buf.write(".\u00ca\3\2\2\2\60\u00cd\3\2\2\2\62\u00d0\3\2\2\2\64\u00d3")
        buf.write("\3\2\2\2\66\u00d6\3\2\2\28\u00db\3\2\2\2:\u00e5\3\2\2")
        buf.write("\2<\u00f0\3\2\2\2>\u00f7\3\2\2\2@\u00f9\3\2\2\2B\u00fd")
        buf.write("\3\2\2\2D\u00ff\3\2\2\2F\u0102\3\2\2\2H\u010d\3\2\2\2")
        buf.write("JL\5\4\3\2KJ\3\2\2\2LM\3\2\2\2MK\3\2\2\2MN\3\2\2\2N\3")
        buf.write("\3\2\2\2OQ\7\3\2\2PR\7H\2\2QP\3\2\2\2QR\3\2\2\2RS\3\2")
        buf.write("\2\2SX\7+\2\2TU\7\66\2\2UW\7+\2\2VT\3\2\2\2WZ\3\2\2\2")
        buf.write("XV\3\2\2\2XY\3\2\2\2Y[\3\2\2\2ZX\3\2\2\2[\\\5\6\4\2\\")
        buf.write("\5\3\2\2\2]h\7.\2\2^`\7\13\2\2_a\5\b\5\2`_\3\2\2\2`a\3")
        buf.write("\2\2\2ac\3\2\2\2bd\5\n\6\2cb\3\2\2\2cd\3\2\2\2df\3\2\2")
        buf.write("\2eg\5\f\7\2fe\3\2\2\2fg\3\2\2\2gi\3\2\2\2h^\3\2\2\2h")
        buf.write("i\3\2\2\2ij\3\2\2\2jk\5\16\b\2kl\7/\2\2l\7\3\2\2\2mn\7")
        buf.write("\f\2\2no\7\62\2\2op\7&\2\2p\t\3\2\2\2qr\7\r\2\2rs\7\62")
        buf.write("\2\2st\7&\2\2t\13\3\2\2\2uv\7\16\2\2vw\7\62\2\2wx\7&\2")
        buf.write("\2x\r\3\2\2\2y{\7\17\2\2z|\5\20\t\2{z\3\2\2\2|}\3\2\2")
        buf.write("\2}{\3\2\2\2}~\3\2\2\2~\177\3\2\2\2\177\u0080\7\20\2\2")
        buf.write("\u0080\u0081\5F$\2\u0081\17\3\2\2\2\u0082\u0085\5\22\n")
        buf.write("\2\u0083\u0085\5\66\34\2\u0084\u0082\3\2\2\2\u0084\u0083")
        buf.write("\3\2\2\2\u0085\21\3\2\2\2\u0086\u0087\7+\2\2\u0087\u008a")
        buf.write("\7\62\2\2\u0088\u008a\3\2\2\2\u0089\u0086\3\2\2\2\u0089")
        buf.write("\u0088\3\2\2\2\u008a\u009d\3\2\2\2\u008b\u009e\7&\2\2")
        buf.write("\u008c\u009e\7\'\2\2\u008d\u009e\7(\2\2\u008e\u009e\7")
        buf.write(")\2\2\u008f\u009e\5:\36\2\u0090\u009e\5\64\33\2\u0091")
        buf.write("\u009e\5\32\16\2\u0092\u009e\5\34\17\2\u0093\u009e\5\36")
        buf.write("\20\2\u0094\u009e\5 \21\2\u0095\u009e\5\"\22\2\u0096\u009e")
        buf.write("\5$\23\2\u0097\u009e\5&\24\2\u0098\u009e\7 \2\2\u0099")
        buf.write("\u009e\7!\2\2\u009a\u009e\5*\26\2\u009b\u009e\5,\27\2")
        buf.write("\u009c\u009e\5\62\32\2\u009d\u008b\3\2\2\2\u009d\u008c")
        buf.write("\3\2\2\2\u009d\u008d\3\2\2\2\u009d\u008e\3\2\2\2\u009d")
        buf.write("\u008f\3\2\2\2\u009d\u0090\3\2\2\2\u009d\u0091\3\2\2\2")
        buf.write("\u009d\u0092\3\2\2\2\u009d\u0093\3\2\2\2\u009d\u0094\3")
        buf.write("\2\2\2\u009d\u0095\3\2\2\2\u009d\u0096\3\2\2\2\u009d\u0097")
        buf.write("\3\2\2\2\u009d\u0098\3\2\2\2\u009d\u0099\3\2\2\2\u009d")
        buf.write("\u009a\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009c\3\2\2\2")
        buf.write("\u009e\23\3\2\2\2\u009f\u00a0\t\2\2\2\u00a0\25\3\2\2\2")
        buf.write("\u00a1\u00a2\7,\2\2\u00a2\u00a3\5\24\13\2\u00a3\u00a4")
        buf.write("\7-\2\2\u00a4\27\3\2\2\2\u00a5\u00a6\7,\2\2\u00a6\u00a7")
        buf.write("\5\24\13\2\u00a7\u00a8\7\63\2\2\u00a8\u00a9\5\24\13\2")
        buf.write("\u00a9\u00aa\7-\2\2\u00aa\31\3\2\2\2\u00ab\u00ac\7\23")
        buf.write("\2\2\u00ac\u00ad\5\26\f\2\u00ad\33\3\2\2\2\u00ae\u00af")
        buf.write("\7\24\2\2\u00af\u00b0\5\26\f\2\u00b0\35\3\2\2\2\u00b1")
        buf.write("\u00b2\7\25\2\2\u00b2\u00b3\5\26\f\2\u00b3\37\3\2\2\2")
        buf.write("\u00b4\u00b5\7\26\2\2\u00b5\u00b6\5\26\f\2\u00b6!\3\2")
        buf.write("\2\2\u00b7\u00b8\7\27\2\2\u00b8\u00b9\5\26\f\2\u00b9#")
        buf.write("\3\2\2\2\u00ba\u00bb\7\30\2\2\u00bb\u00bc\5\26\f\2\u00bc")
        buf.write("%\3\2\2\2\u00bd\u00be\7\31\2\2\u00be\u00bf\5\26\f\2\u00bf")
        buf.write("\'\3\2\2\2\u00c0\u00c1\7 \2\2\u00c1)\3\2\2\2\u00c2\u00c3")
        buf.write("\7\"\2\2\u00c3\u00c4\5\26\f\2\u00c4+\3\2\2\2\u00c5\u00c6")
        buf.write("\7#\2\2\u00c6\u00c7\7,\2\2\u00c7\u00c8\t\3\2\2\u00c8\u00c9")
        buf.write("\7-\2\2\u00c9-\3\2\2\2\u00ca\u00cb\7$\2\2\u00cb\u00cc")
        buf.write("\5\26\f\2\u00cc/\3\2\2\2\u00cd\u00ce\7%\2\2\u00ce\u00cf")
        buf.write("\5\30\r\2\u00cf\61\3\2\2\2\u00d0\u00d1\7\22\2\2\u00d1")
        buf.write("\u00d2\5\30\r\2\u00d2\63\3\2\2\2\u00d3\u00d4\7\21\2\2")
        buf.write("\u00d4\u00d5\5\30\r\2\u00d5\65\3\2\2\2\u00d6\u00d7\7\t")
        buf.write("\2\2\u00d7\u00d8\7,\2\2\u00d8\u00d9\7+\2\2\u00d9\u00da")
        buf.write("\7-\2\2\u00da\67\3\2\2\2\u00db\u00dc\t\4\2\2\u00dc9\3")
        buf.write("\2\2\2\u00dd\u00de\b\36\1\2\u00de\u00e6\7H\2\2\u00df\u00e6")
        buf.write("\7J\2\2\u00e0\u00e6\7+\2\2\u00e1\u00e2\7,\2\2\u00e2\u00e3")
        buf.write("\5:\36\2\u00e3\u00e4\7-\2\2\u00e4\u00e6\3\2\2\2\u00e5")
        buf.write("\u00dd\3\2\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2")
        buf.write("\u00e5\u00e1\3\2\2\2\u00e6\u00ed\3\2\2\2\u00e7\u00e8\f")
        buf.write("\4\2\2\u00e8\u00e9\58\35\2\u00e9\u00ea\5:\36\5\u00ea\u00ec")
        buf.write("\3\2\2\2\u00eb\u00e7\3\2\2\2\u00ec\u00ef\3\2\2\2\u00ed")
        buf.write("\u00eb\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee;\3\2\2\2\u00ef")
        buf.write("\u00ed\3\2\2\2\u00f0\u00f1\t\5\2\2\u00f1\u00f5\7\7\2\2")
        buf.write("\u00f2\u00f3\7\n\2\2\u00f3\u00f6\7+\2\2\u00f4\u00f6\7")
        buf.write("\b\2\2\u00f5\u00f2\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f6=")
        buf.write("\3\2\2\2\u00f7\u00f8\t\6\2\2\u00f8?\3\2\2\2\u00f9\u00fa")
        buf.write("\5:\36\2\u00fa\u00fb\5> \2\u00fb\u00fc\5:\36\2\u00fcA")
        buf.write("\3\2\2\2\u00fd\u00fe\t\7\2\2\u00feC\3\2\2\2\u00ff\u0100")
        buf.write("\7C\2\2\u0100\u0101\5H%\2\u0101E\3\2\2\2\u0102\u0103\5")
        buf.write("H%\2\u0103G\3\2\2\2\u0104\u0105\b%\1\2\u0105\u010e\7+")
        buf.write("\2\2\u0106\u010e\5<\37\2\u0107\u010e\5@!\2\u0108\u0109")
        buf.write("\7,\2\2\u0109\u010a\5H%\2\u010a\u010b\7-\2\2\u010b\u010e")
        buf.write("\3\2\2\2\u010c\u010e\5D#\2\u010d\u0104\3\2\2\2\u010d\u0106")
        buf.write("\3\2\2\2\u010d\u0107\3\2\2\2\u010d\u0108\3\2\2\2\u010d")
        buf.write("\u010c\3\2\2\2\u010e\u0115\3\2\2\2\u010f\u0110\f\4\2\2")
        buf.write("\u0110\u0111\5B\"\2\u0111\u0112\5H%\5\u0112\u0114\3\2")
        buf.write("\2\2\u0113\u010f\3\2\2\2\u0114\u0117\3\2\2\2\u0115\u0113")
        buf.write("\3\2\2\2\u0115\u0116\3\2\2\2\u0116I\3\2\2\2\u0117\u0115")
        buf.write("\3\2\2\2\22MQX`cfh}\u0084\u0089\u009d\u00e5\u00ed\u00f5")
        buf.write("\u010d\u0115")
        return buf.getvalue()


class RuleParser ( Parser ):

    grammarFileName = "RuleParser.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'rule'", "'raw'", "'any'", "'all'", "'of'", 
                     "'them'", "'print'", "'$'", "'meta:'", "'type'", "'url'", 
                     "'description'", "'strings:'", "'condition:'", "'zip.subfile'", 
                     "'apk.subfile'", "'apk.manifest'", "'apk.manifest.activity'", 
                     "'apk.manifest.receiver'", "'apk.manifest.service'", 
                     "'apk.manifest.provider'", "'apk.manifest.permission'", 
                     "'apk.manifest.action'", "'apk.manifest.activities_num'", 
                     "'apk.manifest.receivers_num'", "'apk.manifest.services_num'", 
                     "'apk.manifest.providers_num'", "'apk.manifest.permissions_num'", 
                     "'apk.manifest.actions_num'", "'apk.manifest.main_activity'", 
                     "'apk.manifest.application'", "'apk.dex.string'", "'apk.dex.class'", 
                     "'apk.dex.method'", "'apk.dex.usage'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'nocase'", 
                     "<INVALID>", "'('", "')'", "'{'", "'}'", "'['", "']'", 
                     "'='", "','", "';'", "':'", "'.'", "'++'", "'--'", 
                     "':='", "'...'", "'||'", "'&&'", "'=='", "'!='", "'<'", 
                     "'<='", "'>'", "'>='", "'!'", "'+'", "'-'", "'*'", 
                     "'/'" ]

    symbolicNames = [ "<INVALID>", "RULE", "RAW", "ANY", "ALL", "OF", "THEM", 
                      "PRINT", "DOLLAR", "META", "TYPE", "URL", "DESCRIPTION", 
                      "STRINGS", "CONDITION", "ZIP_SUB_FILE", "APK_SUB_FILE", 
                      "APK_MANIFEST", "APK_MANIFEST_ACTIVITY", "APK_MANIFEST_RECEIVER", 
                      "APK_MANIFEST_SERVICE", "APK_MANIFEST_PROVIDER", "APK_MANIFEST_PERMISSION", 
                      "APK_MANIFEST_ACTION", "APK_MANIFEST_ACTIVITIES_NUM", 
                      "APK_MANIFEST_RECEIVERS_NUM", "APK_MANIFEST_SERVICES_NUM", 
                      "APK_MANIFEST_PROVIDERS_NUM", "APK_MANIFEST_PERMISSIONS_NUM", 
                      "APK_MANIFEST_ACTIONS_NUM", "APK_MANIFEST_MAIN_ACTIVITY", 
                      "APK_MANIFEST_APPLICATION", "APK_DEX_STRING", "APK_DEX_CLASS", 
                      "APK_DEX_METHOD", "APK_DEX_USAGE", "STRING_LIT", "STRING_REGEXP_LIT", 
                      "HEX_LIT", "HEX_REGEXP_LIT", "NOCASE", "IDENTIFIER", 
                      "L_PAREN", "R_PAREN", "L_CURLY", "R_CURLY", "L_BRACKET", 
                      "R_BRACKET", "ASSIGN", "COMMA", "SEMI", "COLON", "DOT", 
                      "PLUS_PLUS", "MINUS_MINUS", "DECLARE_ASSIGN", "ELLIPSIS", 
                      "LOGICAL_OR", "LOGICAL_AND", "EQUALS", "NOT_EQUALS", 
                      "LESS", "LESS_OR_EQUALS", "GREATER", "GREATER_OR_EQUALS", 
                      "NOT", "PLUS", "MINUS", "STAR", "DIV", "DECIMAL_LIT", 
                      "OCTAL_LIT", "FLOAT_LIT", "IMAGINARY_LIT", "WS", "COMMENT", 
                      "TERMINATOR", "LINE_COMMENT" ]

    RULE_rules = 0
    RULE_ruleDec = 1
    RULE_body = 2
    RULE_typeExpression = 3
    RULE_urlExpression = 4
    RULE_descExpression = 5
    RULE_mainExpression = 6
    RULE_lineExpression = 7
    RULE_assignExpression = 8
    RULE_argumentExpression = 9
    RULE_oneArgumentExpression = 10
    RULE_twoArgumentExpression = 11
    RULE_apkManifestExpression = 12
    RULE_apkManifestActivityExpression = 13
    RULE_apkManifestReceiverExpression = 14
    RULE_apkManifestServiceExpression = 15
    RULE_apkManifestProviderExpression = 16
    RULE_apkManifestPermissionExpression = 17
    RULE_apkManifestActionExpression = 18
    RULE_apkManifestMainActivityExpression = 19
    RULE_apkDexStringExpression = 20
    RULE_apkDexClassExpression = 21
    RULE_apkDexMethodExpression = 22
    RULE_apkDexUsageExpression = 23
    RULE_apkSubFileExpression = 24
    RULE_zipSubFileExpression = 25
    RULE_printExpression = 26
    RULE_arithmeticOperator = 27
    RULE_arithmeticExpression = 28
    RULE_ofExpression = 29
    RULE_relationOperator = 30
    RULE_relationExpression = 31
    RULE_logicalOperator = 32
    RULE_notExpression = 33
    RULE_conditionExpression = 34
    RULE_logicalExpression = 35

    ruleNames =  [ "rules", "ruleDec", "body", "typeExpression", "urlExpression", 
                   "descExpression", "mainExpression", "lineExpression", 
                   "assignExpression", "argumentExpression", "oneArgumentExpression", 
                   "twoArgumentExpression", "apkManifestExpression", "apkManifestActivityExpression", 
                   "apkManifestReceiverExpression", "apkManifestServiceExpression", 
                   "apkManifestProviderExpression", "apkManifestPermissionExpression", 
                   "apkManifestActionExpression", "apkManifestMainActivityExpression", 
                   "apkDexStringExpression", "apkDexClassExpression", "apkDexMethodExpression", 
                   "apkDexUsageExpression", "apkSubFileExpression", "zipSubFileExpression", 
                   "printExpression", "arithmeticOperator", "arithmeticExpression", 
                   "ofExpression", "relationOperator", "relationExpression", 
                   "logicalOperator", "notExpression", "conditionExpression", 
                   "logicalExpression" ]

    EOF = Token.EOF
    RULE=1
    RAW=2
    ANY=3
    ALL=4
    OF=5
    THEM=6
    PRINT=7
    DOLLAR=8
    META=9
    TYPE=10
    URL=11
    DESCRIPTION=12
    STRINGS=13
    CONDITION=14
    ZIP_SUB_FILE=15
    APK_SUB_FILE=16
    APK_MANIFEST=17
    APK_MANIFEST_ACTIVITY=18
    APK_MANIFEST_RECEIVER=19
    APK_MANIFEST_SERVICE=20
    APK_MANIFEST_PROVIDER=21
    APK_MANIFEST_PERMISSION=22
    APK_MANIFEST_ACTION=23
    APK_MANIFEST_ACTIVITIES_NUM=24
    APK_MANIFEST_RECEIVERS_NUM=25
    APK_MANIFEST_SERVICES_NUM=26
    APK_MANIFEST_PROVIDERS_NUM=27
    APK_MANIFEST_PERMISSIONS_NUM=28
    APK_MANIFEST_ACTIONS_NUM=29
    APK_MANIFEST_MAIN_ACTIVITY=30
    APK_MANIFEST_APPLICATION=31
    APK_DEX_STRING=32
    APK_DEX_CLASS=33
    APK_DEX_METHOD=34
    APK_DEX_USAGE=35
    STRING_LIT=36
    STRING_REGEXP_LIT=37
    HEX_LIT=38
    HEX_REGEXP_LIT=39
    NOCASE=40
    IDENTIFIER=41
    L_PAREN=42
    R_PAREN=43
    L_CURLY=44
    R_CURLY=45
    L_BRACKET=46
    R_BRACKET=47
    ASSIGN=48
    COMMA=49
    SEMI=50
    COLON=51
    DOT=52
    PLUS_PLUS=53
    MINUS_MINUS=54
    DECLARE_ASSIGN=55
    ELLIPSIS=56
    LOGICAL_OR=57
    LOGICAL_AND=58
    EQUALS=59
    NOT_EQUALS=60
    LESS=61
    LESS_OR_EQUALS=62
    GREATER=63
    GREATER_OR_EQUALS=64
    NOT=65
    PLUS=66
    MINUS=67
    STAR=68
    DIV=69
    DECIMAL_LIT=70
    OCTAL_LIT=71
    FLOAT_LIT=72
    IMAGINARY_LIT=73
    WS=74
    COMMENT=75
    TERMINATOR=76
    LINE_COMMENT=77

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.9.2")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class RulesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ruleDec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(RuleParser.RuleDecContext)
            else:
                return self.getTypedRuleContext(RuleParser.RuleDecContext,i)


        def getRuleIndex(self):
            return RuleParser.RULE_rules

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRules" ):
                return visitor.visitRules(self)
            else:
                return visitor.visitChildren(self)




    def rules(self):

        localctx = RuleParser.RulesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_rules)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 73 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 72
                self.ruleDec()
                self.state = 75 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==RuleParser.RULE):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RuleDecContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RULE(self):
            return self.getToken(RuleParser.RULE, 0)

        def IDENTIFIER(self, i:int=None):
            if i is None:
                return self.getTokens(RuleParser.IDENTIFIER)
            else:
                return self.getToken(RuleParser.IDENTIFIER, i)

        def body(self):
            return self.getTypedRuleContext(RuleParser.BodyContext,0)


        def DECIMAL_LIT(self):
            return self.getToken(RuleParser.DECIMAL_LIT, 0)

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(RuleParser.DOT)
            else:
                return self.getToken(RuleParser.DOT, i)

        def getRuleIndex(self):
            return RuleParser.RULE_ruleDec

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRuleDec" ):
                return visitor.visitRuleDec(self)
            else:
                return visitor.visitChildren(self)




    def ruleDec(self):

        localctx = RuleParser.RuleDecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_ruleDec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 77
            self.match(RuleParser.RULE)
            self.state = 79
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==RuleParser.DECIMAL_LIT:
                self.state = 78
                self.match(RuleParser.DECIMAL_LIT)


            self.state = 81
            self.match(RuleParser.IDENTIFIER)
            self.state = 86
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==RuleParser.DOT:
                self.state = 82
                self.match(RuleParser.DOT)
                self.state = 83
                self.match(RuleParser.IDENTIFIER)
                self.state = 88
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 89
            self.body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BodyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_CURLY(self):
            return self.getToken(RuleParser.L_CURLY, 0)

        def mainExpression(self):
            return self.getTypedRuleContext(RuleParser.MainExpressionContext,0)


        def R_CURLY(self):
            return self.getToken(RuleParser.R_CURLY, 0)

        def META(self):
            return self.getToken(RuleParser.META, 0)

        def typeExpression(self):
            return self.getTypedRuleContext(RuleParser.TypeExpressionContext,0)


        def urlExpression(self):
            return self.getTypedRuleContext(RuleParser.UrlExpressionContext,0)


        def descExpression(self):
            return self.getTypedRuleContext(RuleParser.DescExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_body

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBody" ):
                return visitor.visitBody(self)
            else:
                return visitor.visitChildren(self)




    def body(self):

        localctx = RuleParser.BodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 91
            self.match(RuleParser.L_CURLY)
            self.state = 102
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==RuleParser.META:
                self.state = 92
                self.match(RuleParser.META)
                self.state = 94
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==RuleParser.TYPE:
                    self.state = 93
                    self.typeExpression()


                self.state = 97
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==RuleParser.URL:
                    self.state = 96
                    self.urlExpression()


                self.state = 100
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==RuleParser.DESCRIPTION:
                    self.state = 99
                    self.descExpression()




            self.state = 104
            self.mainExpression()
            self.state = 105
            self.match(RuleParser.R_CURLY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TYPE(self):
            return self.getToken(RuleParser.TYPE, 0)

        def ASSIGN(self):
            return self.getToken(RuleParser.ASSIGN, 0)

        def STRING_LIT(self):
            return self.getToken(RuleParser.STRING_LIT, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_typeExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeExpression" ):
                return visitor.visitTypeExpression(self)
            else:
                return visitor.visitChildren(self)




    def typeExpression(self):

        localctx = RuleParser.TypeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_typeExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 107
            self.match(RuleParser.TYPE)
            self.state = 108
            self.match(RuleParser.ASSIGN)
            self.state = 109
            self.match(RuleParser.STRING_LIT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UrlExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def URL(self):
            return self.getToken(RuleParser.URL, 0)

        def ASSIGN(self):
            return self.getToken(RuleParser.ASSIGN, 0)

        def STRING_LIT(self):
            return self.getToken(RuleParser.STRING_LIT, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_urlExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUrlExpression" ):
                return visitor.visitUrlExpression(self)
            else:
                return visitor.visitChildren(self)




    def urlExpression(self):

        localctx = RuleParser.UrlExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_urlExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 111
            self.match(RuleParser.URL)
            self.state = 112
            self.match(RuleParser.ASSIGN)
            self.state = 113
            self.match(RuleParser.STRING_LIT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DescExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DESCRIPTION(self):
            return self.getToken(RuleParser.DESCRIPTION, 0)

        def ASSIGN(self):
            return self.getToken(RuleParser.ASSIGN, 0)

        def STRING_LIT(self):
            return self.getToken(RuleParser.STRING_LIT, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_descExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDescExpression" ):
                return visitor.visitDescExpression(self)
            else:
                return visitor.visitChildren(self)




    def descExpression(self):

        localctx = RuleParser.DescExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_descExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 115
            self.match(RuleParser.DESCRIPTION)
            self.state = 116
            self.match(RuleParser.ASSIGN)
            self.state = 117
            self.match(RuleParser.STRING_LIT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MainExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRINGS(self):
            return self.getToken(RuleParser.STRINGS, 0)

        def CONDITION(self):
            return self.getToken(RuleParser.CONDITION, 0)

        def conditionExpression(self):
            return self.getTypedRuleContext(RuleParser.ConditionExpressionContext,0)


        def lineExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(RuleParser.LineExpressionContext)
            else:
                return self.getTypedRuleContext(RuleParser.LineExpressionContext,i)


        def getRuleIndex(self):
            return RuleParser.RULE_mainExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMainExpression" ):
                return visitor.visitMainExpression(self)
            else:
                return visitor.visitChildren(self)




    def mainExpression(self):

        localctx = RuleParser.MainExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_mainExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 119
            self.match(RuleParser.STRINGS)
            self.state = 121 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 120
                self.lineExpression()
                self.state = 123 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RuleParser.PRINT) | (1 << RuleParser.ZIP_SUB_FILE) | (1 << RuleParser.APK_SUB_FILE) | (1 << RuleParser.APK_MANIFEST) | (1 << RuleParser.APK_MANIFEST_ACTIVITY) | (1 << RuleParser.APK_MANIFEST_RECEIVER) | (1 << RuleParser.APK_MANIFEST_SERVICE) | (1 << RuleParser.APK_MANIFEST_PROVIDER) | (1 << RuleParser.APK_MANIFEST_PERMISSION) | (1 << RuleParser.APK_MANIFEST_ACTION) | (1 << RuleParser.APK_MANIFEST_MAIN_ACTIVITY) | (1 << RuleParser.APK_MANIFEST_APPLICATION) | (1 << RuleParser.APK_DEX_STRING) | (1 << RuleParser.APK_DEX_CLASS) | (1 << RuleParser.STRING_LIT) | (1 << RuleParser.STRING_REGEXP_LIT) | (1 << RuleParser.HEX_LIT) | (1 << RuleParser.HEX_REGEXP_LIT) | (1 << RuleParser.IDENTIFIER) | (1 << RuleParser.L_PAREN))) != 0) or _la==RuleParser.DECIMAL_LIT or _la==RuleParser.FLOAT_LIT):
                    break

            self.state = 125
            self.match(RuleParser.CONDITION)
            self.state = 126
            self.conditionExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LineExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assignExpression(self):
            return self.getTypedRuleContext(RuleParser.AssignExpressionContext,0)


        def printExpression(self):
            return self.getTypedRuleContext(RuleParser.PrintExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_lineExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLineExpression" ):
                return visitor.visitLineExpression(self)
            else:
                return visitor.visitChildren(self)




    def lineExpression(self):

        localctx = RuleParser.LineExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_lineExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 130
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [RuleParser.ZIP_SUB_FILE, RuleParser.APK_SUB_FILE, RuleParser.APK_MANIFEST, RuleParser.APK_MANIFEST_ACTIVITY, RuleParser.APK_MANIFEST_RECEIVER, RuleParser.APK_MANIFEST_SERVICE, RuleParser.APK_MANIFEST_PROVIDER, RuleParser.APK_MANIFEST_PERMISSION, RuleParser.APK_MANIFEST_ACTION, RuleParser.APK_MANIFEST_MAIN_ACTIVITY, RuleParser.APK_MANIFEST_APPLICATION, RuleParser.APK_DEX_STRING, RuleParser.APK_DEX_CLASS, RuleParser.STRING_LIT, RuleParser.STRING_REGEXP_LIT, RuleParser.HEX_LIT, RuleParser.HEX_REGEXP_LIT, RuleParser.IDENTIFIER, RuleParser.L_PAREN, RuleParser.DECIMAL_LIT, RuleParser.FLOAT_LIT]:
                self.state = 128
                self.assignExpression()
                pass
            elif token in [RuleParser.PRINT]:
                self.state = 129
                self.printExpression()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssignExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(RuleParser.IDENTIFIER, 0)

        def ASSIGN(self):
            return self.getToken(RuleParser.ASSIGN, 0)

        def STRING_LIT(self):
            return self.getToken(RuleParser.STRING_LIT, 0)

        def STRING_REGEXP_LIT(self):
            return self.getToken(RuleParser.STRING_REGEXP_LIT, 0)

        def HEX_LIT(self):
            return self.getToken(RuleParser.HEX_LIT, 0)

        def HEX_REGEXP_LIT(self):
            return self.getToken(RuleParser.HEX_REGEXP_LIT, 0)

        def arithmeticExpression(self):
            return self.getTypedRuleContext(RuleParser.ArithmeticExpressionContext,0)


        def zipSubFileExpression(self):
            return self.getTypedRuleContext(RuleParser.ZipSubFileExpressionContext,0)


        def apkManifestExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkManifestExpressionContext,0)


        def apkManifestActivityExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkManifestActivityExpressionContext,0)


        def apkManifestReceiverExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkManifestReceiverExpressionContext,0)


        def apkManifestServiceExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkManifestServiceExpressionContext,0)


        def apkManifestProviderExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkManifestProviderExpressionContext,0)


        def apkManifestPermissionExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkManifestPermissionExpressionContext,0)


        def apkManifestActionExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkManifestActionExpressionContext,0)


        def APK_MANIFEST_MAIN_ACTIVITY(self):
            return self.getToken(RuleParser.APK_MANIFEST_MAIN_ACTIVITY, 0)

        def APK_MANIFEST_APPLICATION(self):
            return self.getToken(RuleParser.APK_MANIFEST_APPLICATION, 0)

        def apkDexStringExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkDexStringExpressionContext,0)


        def apkDexClassExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkDexClassExpressionContext,0)


        def apkSubFileExpression(self):
            return self.getTypedRuleContext(RuleParser.ApkSubFileExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_assignExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignExpression" ):
                return visitor.visitAssignExpression(self)
            else:
                return visitor.visitChildren(self)




    def assignExpression(self):

        localctx = RuleParser.AssignExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_assignExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 135
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.state = 132
                self.match(RuleParser.IDENTIFIER)
                self.state = 133
                self.match(RuleParser.ASSIGN)
                pass

            elif la_ == 2:
                pass


            self.state = 155
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [RuleParser.STRING_LIT]:
                self.state = 137
                self.match(RuleParser.STRING_LIT)
                pass
            elif token in [RuleParser.STRING_REGEXP_LIT]:
                self.state = 138
                self.match(RuleParser.STRING_REGEXP_LIT)
                pass
            elif token in [RuleParser.HEX_LIT]:
                self.state = 139
                self.match(RuleParser.HEX_LIT)
                pass
            elif token in [RuleParser.HEX_REGEXP_LIT]:
                self.state = 140
                self.match(RuleParser.HEX_REGEXP_LIT)
                pass
            elif token in [RuleParser.IDENTIFIER, RuleParser.L_PAREN, RuleParser.DECIMAL_LIT, RuleParser.FLOAT_LIT]:
                self.state = 141
                self.arithmeticExpression(0)
                pass
            elif token in [RuleParser.ZIP_SUB_FILE]:
                self.state = 142
                self.zipSubFileExpression()
                pass
            elif token in [RuleParser.APK_MANIFEST]:
                self.state = 143
                self.apkManifestExpression()
                pass
            elif token in [RuleParser.APK_MANIFEST_ACTIVITY]:
                self.state = 144
                self.apkManifestActivityExpression()
                pass
            elif token in [RuleParser.APK_MANIFEST_RECEIVER]:
                self.state = 145
                self.apkManifestReceiverExpression()
                pass
            elif token in [RuleParser.APK_MANIFEST_SERVICE]:
                self.state = 146
                self.apkManifestServiceExpression()
                pass
            elif token in [RuleParser.APK_MANIFEST_PROVIDER]:
                self.state = 147
                self.apkManifestProviderExpression()
                pass
            elif token in [RuleParser.APK_MANIFEST_PERMISSION]:
                self.state = 148
                self.apkManifestPermissionExpression()
                pass
            elif token in [RuleParser.APK_MANIFEST_ACTION]:
                self.state = 149
                self.apkManifestActionExpression()
                pass
            elif token in [RuleParser.APK_MANIFEST_MAIN_ACTIVITY]:
                self.state = 150
                self.match(RuleParser.APK_MANIFEST_MAIN_ACTIVITY)
                pass
            elif token in [RuleParser.APK_MANIFEST_APPLICATION]:
                self.state = 151
                self.match(RuleParser.APK_MANIFEST_APPLICATION)
                pass
            elif token in [RuleParser.APK_DEX_STRING]:
                self.state = 152
                self.apkDexStringExpression()
                pass
            elif token in [RuleParser.APK_DEX_CLASS]:
                self.state = 153
                self.apkDexClassExpression()
                pass
            elif token in [RuleParser.APK_SUB_FILE]:
                self.state = 154
                self.apkSubFileExpression()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRING_LIT(self):
            return self.getToken(RuleParser.STRING_LIT, 0)

        def STRING_REGEXP_LIT(self):
            return self.getToken(RuleParser.STRING_REGEXP_LIT, 0)

        def HEX_LIT(self):
            return self.getToken(RuleParser.HEX_LIT, 0)

        def HEX_REGEXP_LIT(self):
            return self.getToken(RuleParser.HEX_REGEXP_LIT, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_argumentExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgumentExpression" ):
                return visitor.visitArgumentExpression(self)
            else:
                return visitor.visitChildren(self)




    def argumentExpression(self):

        localctx = RuleParser.ArgumentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_argumentExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 157
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RuleParser.STRING_LIT) | (1 << RuleParser.STRING_REGEXP_LIT) | (1 << RuleParser.HEX_LIT) | (1 << RuleParser.HEX_REGEXP_LIT))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OneArgumentExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_PAREN(self):
            return self.getToken(RuleParser.L_PAREN, 0)

        def argumentExpression(self):
            return self.getTypedRuleContext(RuleParser.ArgumentExpressionContext,0)


        def R_PAREN(self):
            return self.getToken(RuleParser.R_PAREN, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_oneArgumentExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOneArgumentExpression" ):
                return visitor.visitOneArgumentExpression(self)
            else:
                return visitor.visitChildren(self)




    def oneArgumentExpression(self):

        localctx = RuleParser.OneArgumentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_oneArgumentExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 159
            self.match(RuleParser.L_PAREN)
            self.state = 160
            self.argumentExpression()
            self.state = 161
            self.match(RuleParser.R_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TwoArgumentExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_PAREN(self):
            return self.getToken(RuleParser.L_PAREN, 0)

        def argumentExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(RuleParser.ArgumentExpressionContext)
            else:
                return self.getTypedRuleContext(RuleParser.ArgumentExpressionContext,i)


        def COMMA(self):
            return self.getToken(RuleParser.COMMA, 0)

        def R_PAREN(self):
            return self.getToken(RuleParser.R_PAREN, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_twoArgumentExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTwoArgumentExpression" ):
                return visitor.visitTwoArgumentExpression(self)
            else:
                return visitor.visitChildren(self)




    def twoArgumentExpression(self):

        localctx = RuleParser.TwoArgumentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_twoArgumentExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 163
            self.match(RuleParser.L_PAREN)
            self.state = 164
            self.argumentExpression()
            self.state = 165
            self.match(RuleParser.COMMA)
            self.state = 166
            self.argumentExpression()
            self.state = 167
            self.match(RuleParser.R_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkManifestExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_MANIFEST(self):
            return self.getToken(RuleParser.APK_MANIFEST, 0)

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.OneArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkManifestExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkManifestExpression" ):
                return visitor.visitApkManifestExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkManifestExpression(self):

        localctx = RuleParser.ApkManifestExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_apkManifestExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 169
            self.match(RuleParser.APK_MANIFEST)
            self.state = 170
            self.oneArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkManifestActivityExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_MANIFEST_ACTIVITY(self):
            return self.getToken(RuleParser.APK_MANIFEST_ACTIVITY, 0)

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.OneArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkManifestActivityExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkManifestActivityExpression" ):
                return visitor.visitApkManifestActivityExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkManifestActivityExpression(self):

        localctx = RuleParser.ApkManifestActivityExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_apkManifestActivityExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 172
            self.match(RuleParser.APK_MANIFEST_ACTIVITY)
            self.state = 173
            self.oneArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkManifestReceiverExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_MANIFEST_RECEIVER(self):
            return self.getToken(RuleParser.APK_MANIFEST_RECEIVER, 0)

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.OneArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkManifestReceiverExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkManifestReceiverExpression" ):
                return visitor.visitApkManifestReceiverExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkManifestReceiverExpression(self):

        localctx = RuleParser.ApkManifestReceiverExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_apkManifestReceiverExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 175
            self.match(RuleParser.APK_MANIFEST_RECEIVER)
            self.state = 176
            self.oneArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkManifestServiceExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_MANIFEST_SERVICE(self):
            return self.getToken(RuleParser.APK_MANIFEST_SERVICE, 0)

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.OneArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkManifestServiceExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkManifestServiceExpression" ):
                return visitor.visitApkManifestServiceExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkManifestServiceExpression(self):

        localctx = RuleParser.ApkManifestServiceExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_apkManifestServiceExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 178
            self.match(RuleParser.APK_MANIFEST_SERVICE)
            self.state = 179
            self.oneArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkManifestProviderExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_MANIFEST_PROVIDER(self):
            return self.getToken(RuleParser.APK_MANIFEST_PROVIDER, 0)

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.OneArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkManifestProviderExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkManifestProviderExpression" ):
                return visitor.visitApkManifestProviderExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkManifestProviderExpression(self):

        localctx = RuleParser.ApkManifestProviderExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_apkManifestProviderExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 181
            self.match(RuleParser.APK_MANIFEST_PROVIDER)
            self.state = 182
            self.oneArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkManifestPermissionExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_MANIFEST_PERMISSION(self):
            return self.getToken(RuleParser.APK_MANIFEST_PERMISSION, 0)

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.OneArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkManifestPermissionExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkManifestPermissionExpression" ):
                return visitor.visitApkManifestPermissionExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkManifestPermissionExpression(self):

        localctx = RuleParser.ApkManifestPermissionExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_apkManifestPermissionExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 184
            self.match(RuleParser.APK_MANIFEST_PERMISSION)
            self.state = 185
            self.oneArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkManifestActionExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_MANIFEST_ACTION(self):
            return self.getToken(RuleParser.APK_MANIFEST_ACTION, 0)

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.OneArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkManifestActionExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkManifestActionExpression" ):
                return visitor.visitApkManifestActionExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkManifestActionExpression(self):

        localctx = RuleParser.ApkManifestActionExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_apkManifestActionExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 187
            self.match(RuleParser.APK_MANIFEST_ACTION)
            self.state = 188
            self.oneArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkManifestMainActivityExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_MANIFEST_MAIN_ACTIVITY(self):
            return self.getToken(RuleParser.APK_MANIFEST_MAIN_ACTIVITY, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_apkManifestMainActivityExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkManifestMainActivityExpression" ):
                return visitor.visitApkManifestMainActivityExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkManifestMainActivityExpression(self):

        localctx = RuleParser.ApkManifestMainActivityExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_apkManifestMainActivityExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 190
            self.match(RuleParser.APK_MANIFEST_MAIN_ACTIVITY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkDexStringExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_DEX_STRING(self):
            return self.getToken(RuleParser.APK_DEX_STRING, 0)

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.OneArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkDexStringExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkDexStringExpression" ):
                return visitor.visitApkDexStringExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkDexStringExpression(self):

        localctx = RuleParser.ApkDexStringExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_apkDexStringExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 192
            self.match(RuleParser.APK_DEX_STRING)
            self.state = 193
            self.oneArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkDexClassExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_DEX_CLASS(self):
            return self.getToken(RuleParser.APK_DEX_CLASS, 0)

        def L_PAREN(self):
            return self.getToken(RuleParser.L_PAREN, 0)

        def R_PAREN(self):
            return self.getToken(RuleParser.R_PAREN, 0)

        def IDENTIFIER(self):
            return self.getToken(RuleParser.IDENTIFIER, 0)

        def STRING_LIT(self):
            return self.getToken(RuleParser.STRING_LIT, 0)

        def STRING_REGEXP_LIT(self):
            return self.getToken(RuleParser.STRING_REGEXP_LIT, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_apkDexClassExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkDexClassExpression" ):
                return visitor.visitApkDexClassExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkDexClassExpression(self):

        localctx = RuleParser.ApkDexClassExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_apkDexClassExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 195
            self.match(RuleParser.APK_DEX_CLASS)
            self.state = 196
            self.match(RuleParser.L_PAREN)
            self.state = 197
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RuleParser.STRING_LIT) | (1 << RuleParser.STRING_REGEXP_LIT) | (1 << RuleParser.IDENTIFIER))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 198
            self.match(RuleParser.R_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkDexMethodExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_DEX_METHOD(self):
            return self.getToken(RuleParser.APK_DEX_METHOD, 0)

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.OneArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkDexMethodExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkDexMethodExpression" ):
                return visitor.visitApkDexMethodExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkDexMethodExpression(self):

        localctx = RuleParser.ApkDexMethodExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_apkDexMethodExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 200
            self.match(RuleParser.APK_DEX_METHOD)
            self.state = 201
            self.oneArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkDexUsageExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_DEX_USAGE(self):
            return self.getToken(RuleParser.APK_DEX_USAGE, 0)

        def twoArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.TwoArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkDexUsageExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkDexUsageExpression" ):
                return visitor.visitApkDexUsageExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkDexUsageExpression(self):

        localctx = RuleParser.ApkDexUsageExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_apkDexUsageExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 203
            self.match(RuleParser.APK_DEX_USAGE)
            self.state = 204
            self.twoArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ApkSubFileExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def APK_SUB_FILE(self):
            return self.getToken(RuleParser.APK_SUB_FILE, 0)

        def twoArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.TwoArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_apkSubFileExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitApkSubFileExpression" ):
                return visitor.visitApkSubFileExpression(self)
            else:
                return visitor.visitChildren(self)




    def apkSubFileExpression(self):

        localctx = RuleParser.ApkSubFileExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_apkSubFileExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 206
            self.match(RuleParser.APK_SUB_FILE)
            self.state = 207
            self.twoArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ZipSubFileExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ZIP_SUB_FILE(self):
            return self.getToken(RuleParser.ZIP_SUB_FILE, 0)

        def twoArgumentExpression(self):
            return self.getTypedRuleContext(RuleParser.TwoArgumentExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_zipSubFileExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitZipSubFileExpression" ):
                return visitor.visitZipSubFileExpression(self)
            else:
                return visitor.visitChildren(self)




    def zipSubFileExpression(self):

        localctx = RuleParser.ZipSubFileExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_zipSubFileExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 209
            self.match(RuleParser.ZIP_SUB_FILE)
            self.state = 210
            self.twoArgumentExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PrintExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PRINT(self):
            return self.getToken(RuleParser.PRINT, 0)

        def L_PAREN(self):
            return self.getToken(RuleParser.L_PAREN, 0)

        def IDENTIFIER(self):
            return self.getToken(RuleParser.IDENTIFIER, 0)

        def R_PAREN(self):
            return self.getToken(RuleParser.R_PAREN, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_printExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrintExpression" ):
                return visitor.visitPrintExpression(self)
            else:
                return visitor.visitChildren(self)




    def printExpression(self):

        localctx = RuleParser.PrintExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_printExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 212
            self.match(RuleParser.PRINT)
            self.state = 213
            self.match(RuleParser.L_PAREN)
            self.state = 214
            self.match(RuleParser.IDENTIFIER)
            self.state = 215
            self.match(RuleParser.R_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArithmeticOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PLUS(self):
            return self.getToken(RuleParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(RuleParser.MINUS, 0)

        def STAR(self):
            return self.getToken(RuleParser.STAR, 0)

        def DIV(self):
            return self.getToken(RuleParser.DIV, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_arithmeticOperator

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArithmeticOperator" ):
                return visitor.visitArithmeticOperator(self)
            else:
                return visitor.visitChildren(self)




    def arithmeticOperator(self):

        localctx = RuleParser.ArithmeticOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_arithmeticOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 217
            _la = self._input.LA(1)
            if not(((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (RuleParser.PLUS - 66)) | (1 << (RuleParser.MINUS - 66)) | (1 << (RuleParser.STAR - 66)) | (1 << (RuleParser.DIV - 66)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArithmeticExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.left = None # ArithmeticExpressionContext
            self.inner = None # ArithmeticExpressionContext
            self.right = None # ArithmeticExpressionContext

        def DECIMAL_LIT(self):
            return self.getToken(RuleParser.DECIMAL_LIT, 0)

        def FLOAT_LIT(self):
            return self.getToken(RuleParser.FLOAT_LIT, 0)

        def IDENTIFIER(self):
            return self.getToken(RuleParser.IDENTIFIER, 0)

        def L_PAREN(self):
            return self.getToken(RuleParser.L_PAREN, 0)

        def R_PAREN(self):
            return self.getToken(RuleParser.R_PAREN, 0)

        def arithmeticExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(RuleParser.ArithmeticExpressionContext)
            else:
                return self.getTypedRuleContext(RuleParser.ArithmeticExpressionContext,i)


        def arithmeticOperator(self):
            return self.getTypedRuleContext(RuleParser.ArithmeticOperatorContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_arithmeticExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArithmeticExpression" ):
                return visitor.visitArithmeticExpression(self)
            else:
                return visitor.visitChildren(self)



    def arithmeticExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = RuleParser.ArithmeticExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 56
        self.enterRecursionRule(localctx, 56, self.RULE_arithmeticExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 227
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [RuleParser.DECIMAL_LIT]:
                self.state = 220
                self.match(RuleParser.DECIMAL_LIT)
                pass
            elif token in [RuleParser.FLOAT_LIT]:
                self.state = 221
                self.match(RuleParser.FLOAT_LIT)
                pass
            elif token in [RuleParser.IDENTIFIER]:
                self.state = 222
                self.match(RuleParser.IDENTIFIER)
                pass
            elif token in [RuleParser.L_PAREN]:
                self.state = 223
                self.match(RuleParser.L_PAREN)
                self.state = 224
                localctx.inner = self.arithmeticExpression(0)
                self.state = 225
                self.match(RuleParser.R_PAREN)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 235
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = RuleParser.ArithmeticExpressionContext(self, _parentctx, _parentState)
                    localctx.left = _prevctx
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_arithmeticExpression)
                    self.state = 229
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 230
                    self.arithmeticOperator()
                    self.state = 231
                    localctx.right = self.arithmeticExpression(3) 
                self.state = 237
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class OfExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OF(self):
            return self.getToken(RuleParser.OF, 0)

        def ANY(self):
            return self.getToken(RuleParser.ANY, 0)

        def ALL(self):
            return self.getToken(RuleParser.ALL, 0)

        def DECIMAL_LIT(self):
            return self.getToken(RuleParser.DECIMAL_LIT, 0)

        def DOLLAR(self):
            return self.getToken(RuleParser.DOLLAR, 0)

        def IDENTIFIER(self):
            return self.getToken(RuleParser.IDENTIFIER, 0)

        def THEM(self):
            return self.getToken(RuleParser.THEM, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_ofExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOfExpression" ):
                return visitor.visitOfExpression(self)
            else:
                return visitor.visitChildren(self)




    def ofExpression(self):

        localctx = RuleParser.OfExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_ofExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 238
            _la = self._input.LA(1)
            if not(_la==RuleParser.ANY or _la==RuleParser.ALL or _la==RuleParser.DECIMAL_LIT):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 239
            self.match(RuleParser.OF)
            self.state = 243
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [RuleParser.DOLLAR]:
                self.state = 240
                self.match(RuleParser.DOLLAR)
                self.state = 241
                self.match(RuleParser.IDENTIFIER)
                pass
            elif token in [RuleParser.THEM]:
                self.state = 242
                self.match(RuleParser.THEM)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def GREATER(self):
            return self.getToken(RuleParser.GREATER, 0)

        def GREATER_OR_EQUALS(self):
            return self.getToken(RuleParser.GREATER_OR_EQUALS, 0)

        def EQUALS(self):
            return self.getToken(RuleParser.EQUALS, 0)

        def NOT_EQUALS(self):
            return self.getToken(RuleParser.NOT_EQUALS, 0)

        def LESS(self):
            return self.getToken(RuleParser.LESS, 0)

        def LESS_OR_EQUALS(self):
            return self.getToken(RuleParser.LESS_OR_EQUALS, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_relationOperator

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRelationOperator" ):
                return visitor.visitRelationOperator(self)
            else:
                return visitor.visitChildren(self)




    def relationOperator(self):

        localctx = RuleParser.RelationOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_relationOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 245
            _la = self._input.LA(1)
            if not(((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (RuleParser.EQUALS - 59)) | (1 << (RuleParser.NOT_EQUALS - 59)) | (1 << (RuleParser.LESS - 59)) | (1 << (RuleParser.LESS_OR_EQUALS - 59)) | (1 << (RuleParser.GREATER - 59)) | (1 << (RuleParser.GREATER_OR_EQUALS - 59)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.left = None # ArithmeticExpressionContext
            self.right = None # ArithmeticExpressionContext

        def relationOperator(self):
            return self.getTypedRuleContext(RuleParser.RelationOperatorContext,0)


        def arithmeticExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(RuleParser.ArithmeticExpressionContext)
            else:
                return self.getTypedRuleContext(RuleParser.ArithmeticExpressionContext,i)


        def getRuleIndex(self):
            return RuleParser.RULE_relationExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRelationExpression" ):
                return visitor.visitRelationExpression(self)
            else:
                return visitor.visitChildren(self)




    def relationExpression(self):

        localctx = RuleParser.RelationExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_relationExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 247
            localctx.left = self.arithmeticExpression(0)
            self.state = 248
            self.relationOperator()
            self.state = 249
            localctx.right = self.arithmeticExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LogicalOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LOGICAL_OR(self):
            return self.getToken(RuleParser.LOGICAL_OR, 0)

        def LOGICAL_AND(self):
            return self.getToken(RuleParser.LOGICAL_AND, 0)

        def getRuleIndex(self):
            return RuleParser.RULE_logicalOperator

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogicalOperator" ):
                return visitor.visitLogicalOperator(self)
            else:
                return visitor.visitChildren(self)




    def logicalOperator(self):

        localctx = RuleParser.LogicalOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_logicalOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 251
            _la = self._input.LA(1)
            if not(_la==RuleParser.LOGICAL_OR or _la==RuleParser.LOGICAL_AND):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NotExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NOT(self):
            return self.getToken(RuleParser.NOT, 0)

        def logicalExpression(self):
            return self.getTypedRuleContext(RuleParser.LogicalExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_notExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNotExpression" ):
                return visitor.visitNotExpression(self)
            else:
                return visitor.visitChildren(self)




    def notExpression(self):

        localctx = RuleParser.NotExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_notExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 253
            self.match(RuleParser.NOT)
            self.state = 254
            self.logicalExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConditionExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def logicalExpression(self):
            return self.getTypedRuleContext(RuleParser.LogicalExpressionContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_conditionExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConditionExpression" ):
                return visitor.visitConditionExpression(self)
            else:
                return visitor.visitChildren(self)




    def conditionExpression(self):

        localctx = RuleParser.ConditionExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_conditionExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 256
            self.logicalExpression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LogicalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.left = None # LogicalExpressionContext
            self.inner = None # LogicalExpressionContext
            self.right = None # LogicalExpressionContext

        def IDENTIFIER(self):
            return self.getToken(RuleParser.IDENTIFIER, 0)

        def ofExpression(self):
            return self.getTypedRuleContext(RuleParser.OfExpressionContext,0)


        def relationExpression(self):
            return self.getTypedRuleContext(RuleParser.RelationExpressionContext,0)


        def L_PAREN(self):
            return self.getToken(RuleParser.L_PAREN, 0)

        def R_PAREN(self):
            return self.getToken(RuleParser.R_PAREN, 0)

        def logicalExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(RuleParser.LogicalExpressionContext)
            else:
                return self.getTypedRuleContext(RuleParser.LogicalExpressionContext,i)


        def notExpression(self):
            return self.getTypedRuleContext(RuleParser.NotExpressionContext,0)


        def logicalOperator(self):
            return self.getTypedRuleContext(RuleParser.LogicalOperatorContext,0)


        def getRuleIndex(self):
            return RuleParser.RULE_logicalExpression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogicalExpression" ):
                return visitor.visitLogicalExpression(self)
            else:
                return visitor.visitChildren(self)



    def logicalExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = RuleParser.LogicalExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 70
        self.enterRecursionRule(localctx, 70, self.RULE_logicalExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 267
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.state = 259
                self.match(RuleParser.IDENTIFIER)
                pass

            elif la_ == 2:
                self.state = 260
                self.ofExpression()
                pass

            elif la_ == 3:
                self.state = 261
                self.relationExpression()
                pass

            elif la_ == 4:
                self.state = 262
                self.match(RuleParser.L_PAREN)
                self.state = 263
                localctx.inner = self.logicalExpression(0)
                self.state = 264
                self.match(RuleParser.R_PAREN)
                pass

            elif la_ == 5:
                self.state = 266
                self.notExpression()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 275
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = RuleParser.LogicalExpressionContext(self, _parentctx, _parentState)
                    localctx.left = _prevctx
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalExpression)
                    self.state = 269
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 270
                    self.logicalOperator()
                    self.state = 271
                    localctx.right = self.logicalExpression(3) 
                self.state = 277
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,15,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[28] = self.arithmeticExpression_sempred
        self._predicates[35] = self.logicalExpression_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def arithmeticExpression_sempred(self, localctx:ArithmeticExpressionContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 2)
         

    def logicalExpression_sempred(self, localctx:LogicalExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 2)
         




